home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / share / bison / lalr1.cc < prev    next >
Encoding:
C/C++ Source or Header  |  2006-04-25  |  33.5 KB  |  1,364 lines
  1. m4_divert(-1)
  2.  
  3. # C++ skeleton for Bison
  4.  
  5. # Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
  6.  
  7. # This program is free software; you can redistribute it and/or modify
  8. # it under the terms of the GNU General Public License as published by
  9. # the Free Software Foundation; either version 2 of the License, or
  10. # (at your option) any later version.
  11.  
  12. # This program is distributed in the hope that it will be useful,
  13. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. # GNU General Public License for more details.
  16.  
  17. # You should have received a copy of the GNU General Public License
  18. # along with this program; if not, write to the Free Software
  19. # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  20. # 02110-1301  USA
  21.  
  22. m4_include(b4_pkgdatadir/[c++.m4])
  23.  
  24. # We do want M4 expansion after # for CPP macros.
  25. m4_changecom()
  26. m4_divert(0)dnl
  27. m4_if(b4_defines_flag, 0, [],
  28. [@output @output_header_name@
  29. b4_copyright([C++ Skeleton parser for LALR(1) parsing with Bison],
  30.              [2002, 2003, 2004, 2005])[
  31. /* FIXME: This is wrong, we want computed header guards.
  32.    I don't know why the macros are missing now. :( */
  33. #ifndef PARSER_HEADER_H
  34. # define PARSER_HEADER_H
  35.  
  36. #include <string>
  37. #include <iostream>
  38.  
  39. /* Using locations.  */
  40. #define YYLSP_NEEDED ]b4_locations_flag[
  41.  
  42. namespace yy
  43. {
  44.   class position;
  45.   class location;
  46. }
  47.  
  48. ]b4_token_enums(b4_tokens)[
  49.  
  50. /* Copy the first part of user declarations.  */
  51. ]b4_pre_prologue[
  52.  
  53. ]/* Line __line__ of lalr1.cc.  */
  54. b4_syncline([@oline@], [@ofile@])[
  55.  
  56. #include "stack.hh"
  57. #include "location.hh"
  58.  
  59. /* Enabling traces.  */
  60. #ifndef YYDEBUG
  61. # define YYDEBUG ]b4_debug[
  62. #endif
  63.  
  64. /* Enabling verbose error messages.  */
  65. #ifdef YYERROR_VERBOSE
  66. # undef YYERROR_VERBOSE
  67. # define YYERROR_VERBOSE 1
  68. #else
  69. # define YYERROR_VERBOSE ]b4_error_verbose[
  70. #endif
  71.  
  72. #if YYERROR_VERBOSE
  73. # define YYERROR_VERBOSE_IF(x) x
  74. #else
  75. # define YYERROR_VERBOSE_IF(x) /* empty */
  76. #endif
  77.  
  78. /* Enabling the token table.  */
  79. #ifndef YYTOKEN_TABLE
  80. # define YYTOKEN_TABLE ]b4_token_table[
  81. #endif
  82.  
  83. #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
  84. ]m4_ifdef([b4_stype],
  85. [b4_syncline([b4_stype_line], [b4_file_name])
  86. union YYSTYPE b4_stype;
  87. /* Line __line__ of lalr1.cc.  */
  88. b4_syncline([@oline@], [@ofile@])],
  89. [typedef int YYSTYPE;])[
  90. # define yystype YYSTYPE /* obsolescent; will be withdrawn */
  91. # define YYSTYPE_IS_DECLARED 1
  92. # define YYSTYPE_IS_TRIVIAL 1
  93. #endif
  94.  
  95. /* Copy the second part of user declarations.  */
  96. ]b4_post_prologue[
  97.  
  98. ]/* Line __line__ of lalr1.cc.  */
  99. b4_syncline([@oline@], [@ofile@])[
  100. /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
  101.    If N is 0, then set CURRENT to the empty location which ends
  102.    the previous symbol: RHS[0] (always defined).  */
  103.  
  104. #ifndef YYLLOC_DEFAULT
  105. # define YYLLOC_DEFAULT(Current, Rhs, N)        \
  106. do {                            \
  107.   if (N)                        \
  108.     {                            \
  109.       (Current).begin = (Rhs)[1].begin;            \
  110.       (Current).end   = (Rhs)[N].end;            \
  111.     }                            \
  112.   else                            \
  113.     {                            \
  114.       (Current).begin = (Current).end = (Rhs)[0].end;    \
  115.     }                            \
  116. } while (0)
  117. #endif
  118.  
  119. namespace yy
  120. {
  121.   class ]b4_parser_class_name[;
  122.  
  123.   template <typename P>
  124.   struct traits
  125.   {
  126.   };
  127.  
  128.   template <>
  129.   struct traits<]b4_parser_class_name[>
  130.   {
  131.     typedef ]b4_int_type_for([b4_translate])[ token_number_type;
  132.     typedef ]b4_int_type_for([b4_rhs])[       rhs_number_type;
  133.     typedef int state_type;
  134.     typedef YYSTYPE semantic_type;
  135.     typedef ]b4_location_type[ location_type;
  136.   };
  137. }
  138.  
  139. namespace yy
  140. {
  141.   /// A Bison parser.
  142.   class ]b4_parser_class_name[
  143.   {
  144.     /// Symbol semantic values.
  145.     typedef traits<]b4_parser_class_name[>::semantic_type semantic_type;
  146.     /// Symbol locations.
  147.     typedef traits<]b4_parser_class_name[>::location_type location_type;
  148.  
  149.   public:
  150.     /// Build a parser object.
  151.     ]b4_parser_class_name[ (]b4_parse_param_decl[) :
  152.       yydebug_ (false),
  153.       yycdebug_ (&std::cerr)]b4_parse_param_cons[
  154.     {
  155.     }
  156.  
  157.     virtual ~]b4_parser_class_name[ ()
  158.     {
  159.     }
  160.  
  161.     /// Parse.
  162.     /// \returns  0 iff parsing succeeded.
  163.     virtual int parse ();
  164.  
  165.     /// The current debugging stream.
  166.     std::ostream& debug_stream () const;
  167.     /// Set the current debugging stream.
  168.     void set_debug_stream (std::ostream &);
  169.  
  170.     /// Type for debugging levels.
  171.     typedef int debug_level_type;
  172.     /// The current debugging level.
  173.     debug_level_type debug_level () const;
  174.     /// Set the current debugging level.
  175.     void set_debug_level (debug_level_type l);
  176.  
  177.   private:
  178.     /// Report a syntax error.
  179.     /// \param loc    where the syntax error is found.
  180.     /// \param msg    a description of the syntax error.
  181.     virtual void error (const location_type& loc, const std::string& msg);
  182.  
  183.     /// Generate an error message.
  184.     /// \param tok    the look-ahead token.
  185.     virtual std::string yysyntax_error_ (YYERROR_VERBOSE_IF (int tok));
  186.  
  187. #if YYDEBUG
  188.     /// \brief Report a symbol on the debug stream.
  189.     /// \param yytype       The token type.
  190.     /// \param yyvaluep     Its semantic value.
  191.     /// \param yylocationp  Its location.
  192.     virtual void yysymprint_ (int yytype,
  193.                   const semantic_type* yyvaluep,
  194.                   const location_type* yylocationp);
  195. #endif /* ! YYDEBUG */
  196.  
  197.  
  198.     /// State numbers.
  199.     typedef traits<]b4_parser_class_name[>::state_type state_type;
  200.     /// State stack type.
  201.     typedef stack<state_type>    state_stack_type;
  202.     /// Semantic value stack type.
  203.     typedef stack<semantic_type> semantic_stack_type;
  204.     /// location stack type.
  205.     typedef stack<location_type> location_stack_type;
  206.  
  207.     /// The state stack.
  208.     state_stack_type yystate_stack_;
  209.     /// The semantic value stack.
  210.     semantic_stack_type yysemantic_stack_;
  211.     /// The location stack.
  212.     location_stack_type yylocation_stack_;
  213.  
  214.     /// Internal symbol numbers.
  215.     typedef traits<]b4_parser_class_name[>::token_number_type token_number_type;
  216.     /* Tables.  */
  217.     /// For a state, the index in \a yytable_ of its portion.
  218.     static const ]b4_int_type_for([b4_pact])[ yypact_[];
  219.     static const ]b4_int_type(b4_pact_ninf, b4_pact_ninf)[ yypact_ninf_;
  220.  
  221.     /// For a state, default rule to reduce.
  222.     /// Unless\a  yytable_ specifies something else to do.
  223.     /// Zero means the default is an error.
  224.     static const ]b4_int_type_for([b4_defact])[ yydefact_[];
  225.  
  226.     static const ]b4_int_type_for([b4_pgoto])[ yypgoto_[];
  227.     static const ]b4_int_type_for([b4_defgoto])[ yydefgoto_[];
  228.  
  229.     /// What to do in a state.
  230.     /// \a yytable_[yypact_[s]]: what to do in state \a s.
  231.     /// - if positive, shift that token.
  232.     /// - if negative, reduce the rule which number is the opposite.
  233.     /// - if zero, do what YYDEFACT says.
  234.     static const ]b4_int_type_for([b4_table])[ yytable_[];
  235.     static const ]b4_int_type(b4_table_ninf, b4_table_ninf)[ yytable_ninf_;
  236.  
  237.     static const ]b4_int_type_for([b4_check])[ yycheck_[];
  238.  
  239.     /// For a state, its accessing symbol.
  240.     static const ]b4_int_type_for([b4_stos])[ yystos_[];
  241.  
  242.     /// For a rule, its LHS.
  243.     static const ]b4_int_type_for([b4_r1])[ yyr1_[];
  244.     /// For a rule, its RHS length.
  245.     static const ]b4_int_type_for([b4_r2])[ yyr2_[];
  246.  
  247. #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
  248.     /// For a symbol, its name in clear.
  249.     static const char* const yytname_[];
  250. #endif
  251.  
  252. #if YYERROR_VERBOSE
  253.     /// Convert the symbol name \a n to a form suitable for a diagnostic.
  254.     virtual std::string yytnamerr_ (const char *n);
  255. #endif
  256.  
  257. #if YYDEBUG
  258.     /// A type to store symbol numbers and -1.
  259.     typedef traits<]b4_parser_class_name[>::rhs_number_type rhs_number_type;
  260.     /// A `-1'-separated list of the rules' RHS.
  261.     static const rhs_number_type yyrhs_[];
  262.     /// For each rule, the index of the first RHS symbol in \a yyrhs_.
  263.     static const ]b4_int_type_for([b4_prhs])[ yyprhs_[];
  264.     /// For each rule, its source line number.
  265.     static const ]b4_int_type_for([b4_rline])[ yyrline_[];
  266.     /// For each scanner token number, its symbol number.
  267.     static const ]b4_int_type_for([b4_toknum])[ yytoken_number_[];
  268.     /// Report on the debug stream that the rule \a r is going to be reduced.
  269.     virtual void yyreduce_print_ (int r);
  270.     /// Print the state stack on the debug stream.
  271.     virtual void yystack_print_ ();
  272. #endif
  273.  
  274.     /// Convert a scanner token number to a symbol number.
  275.     inline token_number_type yytranslate_ (int token);
  276.  
  277.     /// \brief Reclaim the memory associated to a symbol.
  278.     /// \param yymsg        Why this token is reclaimed.
  279.     /// \param yytype       The symbol type.
  280.     /// \param yyvaluep     Its semantic value.
  281.     /// \param yylocationp  Its location.
  282.     inline void yydestruct_ (const char* yymsg,
  283.                              int yytype,
  284.                              semantic_type* yyvaluep,
  285.                              location_type* yylocationp);
  286.  
  287.     /// Pop \a n symbols the three stacks.
  288.     inline void yypop_ (unsigned int n = 1);
  289.  
  290.     /* Constants.  */
  291.     static const int yyeof_;
  292.     /* LAST_ -- Last index in TABLE_.  */
  293.     static const int yylast_;
  294.     static const int yynnts_;
  295.     static const int yyempty_;
  296.     static const int yyfinal_;
  297.     static const int yyterror_;
  298.     static const int yyerrcode_;
  299.     static const int yyntokens_;
  300.     static const unsigned int yyuser_token_number_max_;
  301.     static const token_number_type yyundef_token_;
  302.  
  303.     /* State.  */
  304.     int yyn_;
  305.     int yylen_;
  306.     int yystate_;
  307.  
  308.     /* Error handling. */
  309.     int yynerrs_;
  310.     int yyerrstatus_;
  311.  
  312.     /* Debugging.  */
  313.     int yydebug_;
  314.     std::ostream* yycdebug_;
  315.  
  316. ]b4_parse_param_vars[
  317.   };
  318. }
  319.  
  320. #endif /* ! defined PARSER_HEADER_H */]
  321. ])dnl
  322. @output @output_parser_name@
  323. b4_copyright([C++ Skeleton parser for LALR(1) parsing with Bison],
  324.              [2002, 2003, 2004, 2005])
  325. m4_if(b4_prefix[], [yy], [],
  326. [
  327. // Take the name prefix into account.
  328. #define yylex   b4_prefix[]lex])
  329. m4_if(b4_defines_flag, 0, [],
  330. [
  331. #include @output_header_name@])[
  332.  
  333. #ifndef YY_
  334. # if YYENABLE_NLS
  335. #  if ENABLE_NLS
  336. #   include <libintl.h> /* FIXME: INFRINGES ON USER NAME SPACE */
  337. #   define YY_(msgid) dgettext ("bison-runtime", msgid)
  338. #  endif
  339. # endif
  340. # ifndef YY_
  341. #  define YY_(msgid) msgid
  342. # endif
  343. #endif
  344.  
  345. /* A pseudo ostream that takes yydebug_ into account. */
  346. # define YYCDEBUG                            \
  347.   for (bool yydebugcond_ = yydebug_; yydebugcond_; yydebugcond_ = false)    \
  348.     (*yycdebug_)
  349.  
  350. /* Enable debugging if requested.  */
  351. #if YYDEBUG
  352.  
  353. # define YY_SYMBOL_PRINT(Title, Type, Value, Location)    \
  354. do {                            \
  355.   if (yydebug_)                        \
  356.     {                            \
  357.       *yycdebug_ << (Title) << ' ';            \
  358.       yysymprint_ ((Type), (Value), (Location));    \
  359.       *yycdebug_ << std::endl;                \
  360.     }                            \
  361. } while (0)
  362.  
  363. # define YY_REDUCE_PRINT(Rule)        \
  364. do {                    \
  365.   if (yydebug_)                \
  366.     yyreduce_print_ (Rule);        \
  367. } while (0)
  368.  
  369. # define YY_STACK_PRINT()        \
  370. do {                    \
  371.   if (yydebug_)                \
  372.     yystack_print_ ();            \
  373. } while (0)
  374.  
  375. #else /* !YYDEBUG */
  376.  
  377. # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
  378. # define YY_REDUCE_PRINT(Rule)
  379. # define YY_STACK_PRINT()
  380.  
  381. #endif /* !YYDEBUG */
  382.  
  383. #define YYACCEPT    goto yyacceptlab
  384. #define YYABORT        goto yyabortlab
  385. #define YYERROR        goto yyerrorlab
  386.  
  387. #if YYERROR_VERBOSE
  388.  
  389. /* Return YYSTR after stripping away unnecessary quotes and
  390.    backslashes, so that it's suitable for yyerror.  The heuristic is
  391.    that double-quoting is unnecessary unless the string contains an
  392.    apostrophe, a comma, or backslash (other than backslash-backslash).
  393.    YYSTR is taken from yytname.  */
  394. std::string
  395. yy::]b4_parser_class_name[::yytnamerr_ (const char *yystr)
  396. {
  397.   if (*yystr == '"')
  398.     {
  399.       std::string yyr = "";
  400.       char const *yyp = yystr;
  401.  
  402.       for (;;)
  403.     switch (*++yyp)
  404.       {
  405.       case '\'':
  406.       case ',':
  407.         goto do_not_strip_quotes;
  408.  
  409.       case '\\':
  410.         if (*++yyp != '\\')
  411.           goto do_not_strip_quotes;
  412.         /* Fall through.  */
  413.       default:
  414.         yyr += *yyp;
  415.         break;
  416.  
  417.       case '"':
  418.         return yyr;
  419.       }
  420.     do_not_strip_quotes: ;
  421.     }
  422.  
  423.   return yystr;
  424. }
  425.  
  426. #endif
  427.  
  428. #if YYDEBUG
  429. /*--------------------------------.
  430. | Print this symbol on YYOUTPUT.  |
  431. `--------------------------------*/
  432.  
  433. void
  434. yy::]b4_parser_class_name[::yysymprint_ (int yytype,
  435.                          const semantic_type* yyvaluep, const location_type* yylocationp)
  436. {
  437.   /* Pacify ``unused variable'' warnings.  */
  438.   (void) yyvaluep;
  439.   (void) yylocationp;
  440.   /* Backward compatibility, but should be removed eventually. */
  441.   std::ostream& cdebug_ = *yycdebug_;
  442.   (void) cdebug_;
  443.  
  444.   *yycdebug_ << (yytype < yyntokens_ ? "token" : "nterm")
  445.          << ' ' << yytname_[yytype] << " ("
  446.              << *yylocationp << ": ";
  447.   switch (yytype)
  448.     {
  449. ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
  450. [      default:
  451.         break;
  452.     }
  453.   *yycdebug_ << ')';
  454. }
  455. #endif /* ! YYDEBUG */
  456.  
  457. void
  458. yy::]b4_parser_class_name[::yydestruct_ (const char* yymsg,
  459.                          int yytype, semantic_type* yyvaluep, location_type* yylocationp)
  460. {
  461.   /* Pacify ``unused variable'' warnings.  */
  462.   (void) yymsg;
  463.   (void) yyvaluep;
  464.   (void) yylocationp;
  465.  
  466.   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
  467.  
  468.   switch (yytype)
  469.     {
  470. ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[
  471.       default:
  472.         break;
  473.     }
  474. }
  475.  
  476. void
  477. yy::]b4_parser_class_name[::yypop_ (unsigned int n)
  478. {
  479.   yystate_stack_.pop (n);
  480.   yysemantic_stack_.pop (n);
  481.   yylocation_stack_.pop (n);
  482. }
  483.  
  484. std::ostream&
  485. yy::]b4_parser_class_name[::debug_stream () const
  486. {
  487.   return *yycdebug_;
  488. }
  489.  
  490. void
  491. yy::]b4_parser_class_name[::set_debug_stream (std::ostream& o)
  492. {
  493.   yycdebug_ = &o;
  494. }
  495.  
  496.  
  497. yy::]b4_parser_class_name[::debug_level_type
  498. yy::]b4_parser_class_name[::debug_level () const
  499. {
  500.   return yydebug_;
  501. }
  502.  
  503. void
  504. yy::]b4_parser_class_name[::set_debug_level (debug_level_type l)
  505. {
  506.   yydebug_ = l;
  507. }
  508.  
  509.  
  510. int
  511. yy::]b4_parser_class_name[::parse ()
  512. {
  513.   /* Look-ahead and look-ahead in internal form.  */
  514.   int yylooka;
  515.   int yyilooka;
  516.  
  517.   /// Semantic value of the look-ahead.
  518.   semantic_type yylval;
  519.   /// Location of the look-ahead.
  520.   location_type yylloc;
  521.   /// The locations where the error started and ended.
  522.   location yyerror_range[2];
  523.  
  524.   /// $$.
  525.   semantic_type yyval;
  526.   /// @@$.
  527.   location_type yyloc;
  528.  
  529.   int yyresult_;
  530.  
  531.   YYCDEBUG << "Starting parse" << std::endl;
  532.  
  533.   yynerrs_ = 0;
  534.   yyerrstatus_ = 0;
  535.  
  536.   /* Start.  */
  537.   yystate_ = 0;
  538.   yylooka = yyempty_;
  539.  
  540. ]m4_ifdef([b4_initial_action], [
  541. m4_pushdef([b4_at_dollar],     [yylloc])dnl
  542. m4_pushdef([b4_dollar_dollar], [yylval])dnl
  543.   /* User initialization code. */
  544.   b4_initial_action
  545. m4_popdef([b4_dollar_dollar])dnl
  546. m4_popdef([b4_at_dollar])dnl
  547. /* Line __line__ of yacc.c.  */
  548. b4_syncline([@oline@], [@ofile@])])dnl
  549.  
  550. [  /* Initialize the stacks.  The initial state will be pushed in
  551.      yynewstate, since the latter expects the semantical and the
  552.      location values to have been already stored, initialize these
  553.      stacks with a primary value.  */
  554.   yystate_stack_ = state_stack_type (0);
  555.   yysemantic_stack_ = semantic_stack_type (0);
  556.   yylocation_stack_ = location_stack_type (0);
  557.   yysemantic_stack_.push (yylval);
  558.   yylocation_stack_.push (yylloc);
  559.  
  560.   /* New state.  */
  561. yynewstate:
  562.   yystate_stack_.push (yystate_);
  563.   YYCDEBUG << "Entering state " << yystate_ << std::endl;
  564.   goto yybackup;
  565.  
  566.   /* Backup.  */
  567. yybackup:
  568.  
  569.   /* Try to take a decision without look-ahead.  */
  570.   yyn_ = yypact_[yystate_];
  571.   if (yyn_ == yypact_ninf_)
  572.     goto yydefault;
  573.  
  574.   /* Read a look-ahead token.  */
  575.   if (yylooka == yyempty_)
  576.     {
  577.       YYCDEBUG << "Reading a token: ";
  578.       yylooka = ]b4_c_function_call([yylex], [int],
  579. [[YYSTYPE*], [&yylval]][]dnl
  580. b4_location_if([, [[location*], [&yylloc]]])dnl
  581. m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
  582.     }
  583.  
  584.  
  585.   /* Convert token to internal form.  */
  586.   if (yylooka <= yyeof_)
  587.     {
  588.       yylooka = yyilooka = yyeof_;
  589.       YYCDEBUG << "Now at end of input." << std::endl;
  590.     }
  591.   else
  592.     {
  593.       yyilooka = yytranslate_ (yylooka);
  594.       YY_SYMBOL_PRINT ("Next token is", yyilooka, &yylval, &yylloc);
  595.     }
  596.  
  597.   /* If the proper action on seeing token ILOOKA_ is to reduce or to
  598.      detect an error, take that action.  */
  599.   yyn_ += yyilooka;
  600.   if (yyn_ < 0 || yylast_ < yyn_ || yycheck_[yyn_] != yyilooka)
  601.     goto yydefault;
  602.  
  603.   /* Reduce or error.  */
  604.   yyn_ = yytable_[yyn_];
  605.   if (yyn_ < 0)
  606.     {
  607.       if (yyn_ == yytable_ninf_)
  608.     goto yyerrlab;
  609.       else
  610.     {
  611.       yyn_ = -yyn_;
  612.       goto yyreduce;
  613.     }
  614.     }
  615.   else if (yyn_ == 0)
  616.     goto yyerrlab;
  617.  
  618.   /* Accept?  */
  619.   if (yyn_ == yyfinal_)
  620.     goto yyacceptlab;
  621.  
  622.   /* Shift the look-ahead token.  */
  623.   YY_SYMBOL_PRINT ("Shifting", yyilooka, &yylval, &yylloc);
  624.  
  625.   /* Discard the token being shifted unless it is eof.  */
  626.   if (yylooka != yyeof_)
  627.     yylooka = yyempty_;
  628.  
  629.   yysemantic_stack_.push (yylval);
  630.   yylocation_stack_.push (yylloc);
  631.  
  632.   /* Count tokens shifted since error; after three, turn off error
  633.      status.  */
  634.   if (yyerrstatus_)
  635.     --yyerrstatus_;
  636.  
  637.   yystate_ = yyn_;
  638.   goto yynewstate;
  639.  
  640. /*-----------------------------------------------------------.
  641. | yydefault -- do the default action for the current state.  |
  642. `-----------------------------------------------------------*/
  643. yydefault:
  644.   yyn_ = yydefact_[yystate_];
  645.   if (yyn_ == 0)
  646.     goto yyerrlab;
  647.   goto yyreduce;
  648.  
  649. /*-----------------------------.
  650. | yyreduce -- Do a reduction.  |
  651. `-----------------------------*/
  652. yyreduce:
  653.   yylen_ = yyr2_[yyn_];
  654.   /* If LEN_ is nonzero, implement the default value of the action:
  655.      `$$ = $1'.  Otherwise, use the top of the stack.
  656.  
  657.      Otherwise, the following line sets YYVAL to garbage.
  658.      This behavior is undocumented and Bison
  659.      users should not rely upon it.  */
  660.   if (yylen_)
  661.     yyval = yysemantic_stack_[yylen_ - 1];
  662.   else
  663.     yyval = yysemantic_stack_[0];
  664.  
  665.   {
  666.     slice<location_type, location_stack_type> slice (yylocation_stack_, yylen_);
  667.     YYLLOC_DEFAULT (yyloc, slice, yylen_);
  668.   }
  669.   YY_REDUCE_PRINT (yyn_);
  670.   switch (yyn_)
  671.     {
  672.       ]b4_actions[
  673.       default: break;
  674.     }
  675.  
  676. ]/* Line __line__ of lalr1.cc.  */
  677. b4_syncline([@oline@], [@ofile@])[
  678.  
  679.   yypop_ (yylen_);
  680.  
  681.   YY_STACK_PRINT ();
  682.  
  683.   yysemantic_stack_.push (yyval);
  684.   yylocation_stack_.push (yyloc);
  685.  
  686.   /* Shift the result of the reduction.  */
  687.   yyn_ = yyr1_[yyn_];
  688.   yystate_ = yypgoto_[yyn_ - yyntokens_] + yystate_stack_[0];
  689.   if (0 <= yystate_ && yystate_ <= yylast_
  690.       && yycheck_[yystate_] == yystate_stack_[0])
  691.     yystate_ = yytable_[yystate_];
  692.   else
  693.     yystate_ = yydefgoto_[yyn_ - yyntokens_];
  694.   goto yynewstate;
  695.  
  696. /*------------------------------------.
  697. | yyerrlab -- here on detecting error |
  698. `------------------------------------*/
  699. yyerrlab:
  700.   /* If not already recovering from an error, report this error.  */
  701.   if (!yyerrstatus_)
  702.     {
  703.       ++yynerrs_;
  704.       error (yylloc, yysyntax_error_ (YYERROR_VERBOSE_IF (yyilooka)));
  705.     }
  706.  
  707.   yyerror_range[0] = yylloc;
  708.   if (yyerrstatus_ == 3)
  709.     {
  710.       /* If just tried and failed to reuse look-ahead token after an
  711.      error, discard it.  */
  712.  
  713.       if (yylooka <= yyeof_)
  714.         {
  715.       /* Return failure if at end of input.  */
  716.       if (yylooka == yyeof_)
  717.         YYABORT;
  718.         }
  719.       else
  720.         {
  721.           yydestruct_ ("Error: discarding", yyilooka, &yylval, &yylloc);
  722.           yylooka = yyempty_;
  723.         }
  724.     }
  725.  
  726.   /* Else will try to reuse look-ahead token after shifting the error
  727.      token.  */
  728.   goto yyerrlab1;
  729.  
  730.  
  731. /*---------------------------------------------------.
  732. | yyerrorlab -- error raised explicitly by YYERROR.  |
  733. `---------------------------------------------------*/
  734. yyerrorlab:
  735.  
  736.   /* Pacify compilers like GCC when the user code never invokes
  737.      YYERROR and the label yyerrorlab therefore never appears in user
  738.      code.  */
  739.   if (false)
  740.     goto yyerrorlab;
  741.  
  742.   yyerror_range[0] = yylocation_stack_[yylen_ - 1];
  743.   yypop_ (yylen_);
  744.   yystate_ = yystate_stack_[0];
  745.   goto yyerrlab1;
  746.  
  747. /*-------------------------------------------------------------.
  748. | yyerrlab1 -- common code for both syntax error and YYERROR.  |
  749. `-------------------------------------------------------------*/
  750. yyerrlab1:
  751.   yyerrstatus_ = 3;    /* Each real token shifted decrements this.  */
  752.  
  753.   for (;;)
  754.     {
  755.       yyn_ = yypact_[yystate_];
  756.       if (yyn_ != yypact_ninf_)
  757.     {
  758.       yyn_ += yyterror_;
  759.       if (0 <= yyn_ && yyn_ <= yylast_ && yycheck_[yyn_] == yyterror_)
  760.         {
  761.           yyn_ = yytable_[yyn_];
  762.           if (0 < yyn_)
  763.         break;
  764.         }
  765.     }
  766.  
  767.       /* Pop the current state because it cannot handle the error token.  */
  768.       if (yystate_stack_.height () == 1)
  769.     YYABORT;
  770.  
  771.       yyerror_range[0] = yylocation_stack_[0];
  772.       yydestruct_ ("Error: popping",
  773.                    yystos_[yystate_],
  774.                    &yysemantic_stack_[0], &yylocation_stack_[0]);
  775.       yypop_ ();
  776.       yystate_ = yystate_stack_[0];
  777.       YY_STACK_PRINT ();
  778.     }
  779.  
  780.   if (yyn_ == yyfinal_)
  781.     goto yyacceptlab;
  782.  
  783.   yyerror_range[1] = yylloc;
  784.   // Using YYLLOC is tempting, but would change the location of
  785.   // the look-ahead.  YYLOC is available though.
  786.   YYLLOC_DEFAULT (yyloc, yyerror_range - 1, 2);
  787.   yysemantic_stack_.push (yylval);
  788.   yylocation_stack_.push (yyloc);
  789.  
  790.   /* Shift the error token. */
  791.   YY_SYMBOL_PRINT ("Shifting", yystos_[yyn_],
  792.            &yysemantic_stack_[0], &yylocation_stack_[0]);
  793.  
  794.   yystate_ = yyn_;
  795.   goto yynewstate;
  796.  
  797.   /* Accept.  */
  798. yyacceptlab:
  799.   yyresult_ = 0;
  800.   goto yyreturn;
  801.  
  802.   /* Abort.  */
  803. yyabortlab:
  804.   yyresult_ = 1;
  805.   goto yyreturn;
  806.  
  807. yyreturn:
  808.   if (yylooka != yyeof_ && yylooka != yyempty_)
  809.     yydestruct_ ("Cleanup: discarding lookahead", yyilooka, &yylval, &yylloc);
  810.  
  811.   while (yystate_stack_.height () != 1)
  812.     {
  813.       yydestruct_ ("Cleanup: popping",
  814.            yystos_[yystate_stack_[0]],
  815.            &yysemantic_stack_[0],
  816.            &yylocation_stack_[0]);
  817.       yypop_ ();
  818.     }
  819.  
  820.   return yyresult_;
  821. }
  822.  
  823. // Generate an error message.
  824. std::string
  825. yy::]b4_parser_class_name[::yysyntax_error_ (YYERROR_VERBOSE_IF (int tok))
  826. {
  827.   std::string res;
  828. #if YYERROR_VERBOSE
  829.   yyn_ = yypact_[yystate_];
  830.   if (yypact_ninf_ < yyn_ && yyn_ < yylast_)
  831.     {
  832.       /* Start YYX at -YYN if negative to avoid negative indexes in
  833.          YYCHECK.  */
  834.       int yyxbegin = yyn_ < 0 ? -yyn_ : 0;
  835.  
  836.       /* Stay within bounds of both yycheck and yytname.  */
  837.       int yychecklim = yylast_ - yyn_;
  838.       int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
  839.       int count = 0;
  840.       for (int x = yyxbegin; x < yyxend; ++x)
  841.         if (yycheck_[x + yyn_] == x && x != yyterror_)
  842.           ++count;
  843.  
  844.       // FIXME: This method of building the message is not compatible
  845.       // with internationalization.  It should work like yacc.c does it.
  846.       // That is, first build a string that looks like this:
  847.       // "syntax error, unexpected %s or %s or %s"
  848.       // Then, invoke YY_ on this string.
  849.       // Finally, use the string as a format to output
  850.       // yytname_[tok], etc.
  851.       // Until this gets fixed, this message appears in English only.
  852.       res = "syntax error, unexpected ";
  853.       res += yytnamerr_ (yytname_[tok]);
  854.       if (count < 5)
  855.         {
  856.           count = 0;
  857.           for (int x = yyxbegin; x < yyxend; ++x)
  858.             if (yycheck_[x + yyn_] == x && x != yyterror_)
  859.               {
  860.                 res += (!count++) ? ", expecting " : " or ";
  861.                 res += yytnamerr_ (yytname_[x]);
  862.               }
  863.         }
  864.     }
  865.   else
  866. #endif
  867.     res = YY_("syntax error");
  868.   return res;
  869. }
  870.  
  871.  
  872. /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
  873.    STATE-NUM.  */
  874. const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) yy::b4_parser_class_name::yypact_ninf_ = b4_pact_ninf[;
  875. const ]b4_int_type_for([b4_pact])[
  876. yy::]b4_parser_class_name[::yypact_[] =
  877. {
  878.   ]b4_pact[
  879. };
  880.  
  881. /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
  882.    doesn't specify something else to do.  Zero means the default is an
  883.    error.  */
  884. const ]b4_int_type_for([b4_defact])[
  885. yy::]b4_parser_class_name[::yydefact_[] =
  886. {
  887.   ]b4_defact[
  888. };
  889.  
  890. /* YYPGOTO[NTERM-NUM].  */
  891. const ]b4_int_type_for([b4_pgoto])[
  892. yy::]b4_parser_class_name[::yypgoto_[] =
  893. {
  894.   ]b4_pgoto[
  895. };
  896.  
  897. /* YYDEFGOTO[NTERM-NUM].  */
  898. const ]b4_int_type_for([b4_defgoto])[
  899. yy::]b4_parser_class_name[::yydefgoto_[] =
  900. {
  901.   ]b4_defgoto[
  902. };
  903.  
  904. /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
  905.    positive, shift that token.  If negative, reduce the rule which
  906.    number is the opposite.  If zero, do what YYDEFACT says.  */
  907. const ]b4_int_type(b4_table_ninf, b4_table_ninf) yy::b4_parser_class_name::yytable_ninf_ = b4_table_ninf[;
  908. const ]b4_int_type_for([b4_table])[
  909. yy::]b4_parser_class_name[::yytable_[] =
  910. {
  911.   ]b4_table[
  912. };
  913.  
  914. /* YYCHECK.  */
  915. const ]b4_int_type_for([b4_check])[
  916. yy::]b4_parser_class_name[::yycheck_[] =
  917. {
  918.   ]b4_check[
  919. };
  920.  
  921. /* STOS_[STATE-NUM] -- The (internal number of the) accessing
  922.    symbol of state STATE-NUM.  */
  923. const ]b4_int_type_for([b4_stos])[
  924. yy::]b4_parser_class_name[::yystos_[] =
  925. {
  926.   ]b4_stos[
  927. };
  928.  
  929. #if YYDEBUG
  930. /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
  931.    to YYLEX-NUM.  */
  932. const ]b4_int_type_for([b4_toknum])[
  933. yy::]b4_parser_class_name[::yytoken_number_[] =
  934. {
  935.   ]b4_toknum[
  936. };
  937. #endif
  938.  
  939. /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
  940. const ]b4_int_type_for([b4_r1])[
  941. yy::]b4_parser_class_name[::yyr1_[] =
  942. {
  943.   ]b4_r1[
  944. };
  945.  
  946. /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
  947. const ]b4_int_type_for([b4_r2])[
  948. yy::]b4_parser_class_name[::yyr2_[] =
  949. {
  950.   ]b4_r2[
  951. };
  952.  
  953. #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
  954. /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
  955.    First, the terminals, then, starting at \a yyntokens_, nonterminals. */
  956. const char*
  957. const yy::]b4_parser_class_name[::yytname_[] =
  958. {
  959.   ]b4_tname[
  960. };
  961. #endif
  962.  
  963. #if YYDEBUG
  964. /* YYRHS -- A `-1'-separated list of the rules' RHS. */
  965. const yy::]b4_parser_class_name[::rhs_number_type
  966. yy::]b4_parser_class_name[::yyrhs_[] =
  967. {
  968.   ]b4_rhs[
  969. };
  970.  
  971. /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
  972.    YYRHS.  */
  973. const ]b4_int_type_for([b4_prhs])[
  974. yy::]b4_parser_class_name[::yyprhs_[] =
  975. {
  976.   ]b4_prhs[
  977. };
  978.  
  979. /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
  980. const ]b4_int_type_for([b4_rline])[
  981. yy::]b4_parser_class_name[::yyrline_[] =
  982. {
  983.   ]b4_rline[
  984. };
  985.  
  986. // Print the state stack on the debug stream.
  987. void
  988. yy::]b4_parser_class_name[::yystack_print_ ()
  989. {
  990.   *yycdebug_ << "Stack now";
  991.   for (state_stack_type::const_iterator i = yystate_stack_.begin ();
  992.        i != yystate_stack_.end (); ++i)
  993.     *yycdebug_ << ' ' << *i;
  994.   *yycdebug_ << std::endl;
  995. }
  996.  
  997. // Report on the debug stream that the rule \a yyrule is going to be reduced.
  998. void
  999. yy::]b4_parser_class_name[::yyreduce_print_ (int yyrule)
  1000. {
  1001.   unsigned int yylno = yyrline_[yyrule];
  1002.   /* Print the symbols being reduced, and their result.  */
  1003.   *yycdebug_ << "Reducing stack by rule " << yyn_ - 1
  1004.              << " (line " << yylno << "), ";
  1005.   for (]b4_int_type_for([b4_prhs])[ i = yyprhs_[yyn_];
  1006.        0 <= yyrhs_[i]; ++i)
  1007.     *yycdebug_ << yytname_[yyrhs_[i]] << ' ';
  1008.   *yycdebug_ << "-> " << yytname_[yyr1_[yyn_]] << std::endl;
  1009. }
  1010. #endif // YYDEBUG
  1011.  
  1012. /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
  1013. yy::]b4_parser_class_name[::token_number_type
  1014. yy::]b4_parser_class_name[::yytranslate_ (int token)
  1015. {
  1016.   static
  1017.   const token_number_type
  1018.   translate_table[] =
  1019.   {
  1020.     ]b4_translate[
  1021.   };
  1022.   if ((unsigned int) token <= yyuser_token_number_max_)
  1023.     return translate_table[token];
  1024.   else
  1025.     return yyundef_token_;
  1026. }
  1027.  
  1028. const int yy::]b4_parser_class_name[::yyeof_ = 0;
  1029. const int yy::]b4_parser_class_name[::yylast_ = ]b4_last[;
  1030. const int yy::]b4_parser_class_name[::yynnts_ = ]b4_nterms_number[;
  1031. const int yy::]b4_parser_class_name[::yyempty_ = -2;
  1032. const int yy::]b4_parser_class_name[::yyfinal_ = ]b4_final_state_number[;
  1033. const int yy::]b4_parser_class_name[::yyterror_ = 1;
  1034. const int yy::]b4_parser_class_name[::yyerrcode_ = 256;
  1035. const int yy::]b4_parser_class_name[::yyntokens_ = ]b4_tokens_number[;
  1036.  
  1037. const unsigned int yy::]b4_parser_class_name[::yyuser_token_number_max_ = ]b4_user_token_number_max[;
  1038. const yy::]b4_parser_class_name[::token_number_type yy::]b4_parser_class_name[::yyundef_token_ = ]b4_undef_token_number[;
  1039.  
  1040. ]b4_epilogue
  1041. dnl
  1042. @output stack.hh
  1043. b4_copyright([stack handling for Bison C++ parsers], [2002, 2003, 2004, 2005])[
  1044.  
  1045. #ifndef BISON_STACK_HH
  1046. # define BISON_STACK_HH
  1047.  
  1048. #include <deque>
  1049.  
  1050. namespace yy
  1051. {
  1052.   template <class T, class S = std::deque<T> >
  1053.   class stack
  1054.   {
  1055.   public:
  1056.  
  1057.     // Hide our reversed order.
  1058.     typedef typename S::reverse_iterator iterator;
  1059.     typedef typename S::const_reverse_iterator const_iterator;
  1060.  
  1061.     stack () : seq_ ()
  1062.     {
  1063.     }
  1064.  
  1065.     stack (unsigned int n) : seq_ (n)
  1066.     {
  1067.     }
  1068.  
  1069.     inline
  1070.     T&
  1071.     operator [] (unsigned int i)
  1072.     {
  1073.       return seq_[i];
  1074.     }
  1075.  
  1076.     inline
  1077.     const T&
  1078.     operator [] (unsigned int i) const
  1079.     {
  1080.       return seq_[i];
  1081.     }
  1082.  
  1083.     inline
  1084.     void
  1085.     push (const T& t)
  1086.     {
  1087.       seq_.push_front (t);
  1088.     }
  1089.  
  1090.     inline
  1091.     void
  1092.     pop (unsigned int n = 1)
  1093.     {
  1094.       for (; n; --n)
  1095.     seq_.pop_front ();
  1096.     }
  1097.  
  1098.     inline
  1099.     unsigned int
  1100.     height () const
  1101.     {
  1102.       return seq_.size ();
  1103.     }
  1104.  
  1105.     inline const_iterator begin () const { return seq_.rbegin (); }
  1106.     inline const_iterator end () const { return seq_.rend (); }
  1107.  
  1108.   private:
  1109.  
  1110.     S seq_;
  1111.   };
  1112.  
  1113.   /// Present a slice of the top of a stack.
  1114.   template <class T, class S = stack<T> >
  1115.   class slice
  1116.   {
  1117.   public:
  1118.  
  1119.     slice (const S& stack,
  1120.        unsigned int range) : stack_ (stack),
  1121.                  range_ (range)
  1122.     {
  1123.     }
  1124.  
  1125.     inline
  1126.     const T&
  1127.     operator [] (unsigned int i) const
  1128.     {
  1129.       return stack_[range_ - i];
  1130.     }
  1131.  
  1132.   private:
  1133.  
  1134.     const S& stack_;
  1135.     unsigned int range_;
  1136.   };
  1137. }
  1138.  
  1139. #endif // not BISON_STACK_HH]
  1140. dnl
  1141. @output position.hh
  1142. b4_copyright([Position class for Bison C++ parsers], [2002, 2003, 2004, 2005])[
  1143.  
  1144. /**
  1145.  ** \file position.hh
  1146.  ** Define the position class.
  1147.  */
  1148.  
  1149. #ifndef BISON_POSITION_HH
  1150. # define BISON_POSITION_HH
  1151.  
  1152. # include <iostream>
  1153. # include <string>
  1154.  
  1155. namespace yy
  1156. {
  1157.   /// Abstract a position.
  1158.   class position
  1159.   {
  1160.   public:
  1161.     /// Initial column number.
  1162.     static const unsigned int initial_column = 0;
  1163.     /// Initial line number.
  1164.     static const unsigned int initial_line = 1;
  1165.  
  1166.     /** \name Ctor & dtor.
  1167.      ** \{ */
  1168.   public:
  1169.     /// Construct a position.
  1170.     position () :
  1171.       filename (0),
  1172.       line (initial_line),
  1173.       column (initial_column)
  1174.     {
  1175.     }
  1176.     /** \} */
  1177.  
  1178.  
  1179.     /** \name Line and Column related manipulators
  1180.      ** \{ */
  1181.   public:
  1182.     /// (line related) Advance to the COUNT next lines.
  1183.     inline void lines (int count = 1)
  1184.     {
  1185.       column = initial_column;
  1186.       line += count;
  1187.     }
  1188.  
  1189.     /// (column related) Advance to the COUNT next columns.
  1190.     inline void columns (int count = 1)
  1191.     {
  1192.       int leftmost = initial_column;
  1193.       int current  = column;
  1194.       if (leftmost <= current + count)
  1195.     column += count;
  1196.       else
  1197.     column = initial_column;
  1198.     }
  1199.     /** \} */
  1200.  
  1201.   public:
  1202.     /// File name to which this position refers.
  1203.     ]b4_filename_type[* filename;
  1204.     /// Current line number.
  1205.     unsigned int line;
  1206.     /// Current column number.
  1207.     unsigned int column;
  1208.   };
  1209.  
  1210.   /// Add and assign a position.
  1211.   inline const position&
  1212.   operator+= (position& res, const int width)
  1213.   {
  1214.     res.columns (width);
  1215.     return res;
  1216.   }
  1217.  
  1218.   /// Add two position objects.
  1219.   inline const position
  1220.   operator+ (const position& begin, const int width)
  1221.   {
  1222.     position res = begin;
  1223.     return res += width;
  1224.   }
  1225.  
  1226.   /// Add and assign a position.
  1227.   inline const position&
  1228.   operator-= (position& res, const int width)
  1229.   {
  1230.     return res += -width;
  1231.   }
  1232.  
  1233.   /// Add two position objects.
  1234.   inline const position
  1235.   operator- (const position& begin, const int width)
  1236.   {
  1237.     return begin + -width;
  1238.   }
  1239.  
  1240.   /** \brief Intercept output stream redirection.
  1241.    ** \param ostr the destination output stream
  1242.    ** \param pos a reference to the position to redirect
  1243.    */
  1244.   inline std::ostream&
  1245.   operator<< (std::ostream& ostr, const position& pos)
  1246.   {
  1247.     if (pos.filename)
  1248.       ostr << *pos.filename << ':';
  1249.     return ostr << pos.line << '.' << pos.column;
  1250.   }
  1251.  
  1252. }
  1253. #endif // not BISON_POSITION_HH]
  1254. @output location.hh
  1255. b4_copyright([Location class for Bison C++ parsers], [2002, 2003, 2004, 2005])[
  1256.  
  1257. /**
  1258.  ** \file location.hh
  1259.  ** Define the location class.
  1260.  */
  1261.  
  1262. #ifndef BISON_LOCATION_HH
  1263. # define BISON_LOCATION_HH
  1264.  
  1265. # include <iostream>
  1266. # include <string>
  1267. # include "position.hh"
  1268.  
  1269. namespace yy
  1270. {
  1271.  
  1272.   /// Abstract a location.
  1273.   class location
  1274.   {
  1275.     /** \name Ctor & dtor.
  1276.      ** \{ */
  1277.   public:
  1278.     /// Construct a location.
  1279.     location () :
  1280.       begin (),
  1281.       end ()
  1282.     {
  1283.     }
  1284.     /** \} */
  1285.  
  1286.  
  1287.     /** \name Line and Column related manipulators
  1288.      ** \{ */
  1289.   public:
  1290.     /// Reset initial location to final location.
  1291.     inline void step ()
  1292.     {
  1293.       begin = end;
  1294.     }
  1295.  
  1296.     /// Extend the current location to the COUNT next columns.
  1297.     inline void columns (unsigned int count = 1)
  1298.     {
  1299.       end += count;
  1300.     }
  1301.  
  1302.     /// Extend the current location to the COUNT next lines.
  1303.     inline void lines (unsigned int count = 1)
  1304.     {
  1305.       end.lines (count);
  1306.     }
  1307.     /** \} */
  1308.  
  1309.  
  1310.   public:
  1311.     /// Beginning of the located region.
  1312.     position begin;
  1313.     /// End of the located region.
  1314.     position end;
  1315.   };
  1316.  
  1317.   /// Join two location objects to create a location.
  1318.   inline const location operator+ (const location& begin, const location& end)
  1319.   {
  1320.     location res = begin;
  1321.     res.end = end.end;
  1322.     return res;
  1323.   }
  1324.  
  1325.   /// Add two location objects.
  1326.   inline const location operator+ (const location& begin, unsigned int width)
  1327.   {
  1328.     location res = begin;
  1329.     res.columns (width);
  1330.     return res;
  1331.   }
  1332.  
  1333.   /// Add and assign a location.
  1334.   inline location& operator+= (location& res, unsigned int width)
  1335.   {
  1336.     res.columns (width);
  1337.     return res;
  1338.   }
  1339.  
  1340.   /** \brief Intercept output stream redirection.
  1341.    ** \param ostr the destination output stream
  1342.    ** \param loc a reference to the location to redirect
  1343.    **
  1344.    ** Avoid duplicate information.
  1345.    */
  1346.   inline std::ostream& operator<< (std::ostream& ostr, const location& loc)
  1347.   {
  1348.     position last = loc.end - 1;
  1349.     ostr << loc.begin;
  1350.     if (last.filename
  1351.     && (!loc.begin.filename
  1352.         || *loc.begin.filename != *last.filename))
  1353.       ostr << '-' << last;
  1354.     else if (loc.begin.line != last.line)
  1355.       ostr << '-' << last.line  << '.' << last.column;
  1356.     else if (loc.begin.column != last.column)
  1357.       ostr << '-' << last.column;
  1358.     return ostr;
  1359.   }
  1360.  
  1361. }
  1362.  
  1363. #endif // not BISON_LOCATION_HH]
  1364.